home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / gepackte_disketten / 1994 / 08_94_5.dms / 08_94_5.adf / term-4.0-Source.lha / termPickFile.c < prev    next >
C/C++ Source or Header  |  1994-06-26  |  15KB  |  732 lines
  1. /*
  2. **    termPickFile.c
  3. **
  4. **    Simplified file selection routines
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. #include <exec/resident.h>
  13.  
  14. enum    {    GAD_LIST=1,GAD_USE,GAD_SELECT,GAD_CANCEL };
  15.  
  16. BOOLEAN __regargs
  17. ValidateFile(STRPTR FileName,LONG Type,STRPTR RealName)
  18. {
  19.     BOOLEAN    Valid = FALSE;
  20.     BPTR    Segment;
  21.  
  22.     if(Segment = LoadSeg(FileName))
  23.     {
  24.         ULONG    *SegmentData;
  25.         BPTR     SegPtr = Segment;
  26.         UWORD    *Match;
  27.         BOOLEAN     GotIt = FALSE;
  28.         LONG     Size;
  29.  
  30.         do
  31.         {
  32.             SegmentData = (ULONG *)BADDR(SegPtr);
  33.  
  34.             SegPtr    = (BPTR)SegmentData[0];
  35.             Size    = SegmentData[-1] - 2 * sizeof(ULONG) - sizeof(struct Resident);
  36.             Match    = (UWORD *)(SegmentData + 1);
  37.  
  38.             while(!GotIt && Size > 0)
  39.             {
  40.                 if(*Match == RTC_MATCHWORD)
  41.                 {
  42.                     struct Resident *Resident = (struct Resident *)Match;
  43.  
  44.                     if(Resident -> rt_MatchTag == Resident)
  45.                     {
  46.                         if(Resident -> rt_Type == Type && Resident -> rt_Name)
  47.                         {
  48.                             if(!Stricmp(FilePart(FileName),Resident -> rt_Name))
  49.                             {
  50.                                 if(RealName)
  51.                                     strcpy(RealName,Resident -> rt_Name);
  52.  
  53.                                 Valid = TRUE;
  54.                             }
  55.                         }
  56.  
  57.                         GotIt = TRUE;
  58.                     }
  59.                 }
  60.  
  61.                 Match    += 2;
  62.                 Size    -= sizeof(ULONG);
  63.             }
  64.         }
  65.         while(!GotIt && SegPtr);
  66.  
  67.         UnLoadSeg(Segment);
  68.     }
  69.  
  70.     return(Valid);
  71. }
  72.  
  73.     /* AddFile(struct List *List,STRPTR Name):
  74.      *
  75.      *    Add another file to the list:
  76.      */
  77.  
  78. STATIC VOID __regargs
  79. AddFile(struct List *List,STRPTR Name)
  80. {
  81.     struct Node *NewNode;
  82.  
  83.     if(NewNode = CreateNode(Name))
  84.     {
  85.         struct Node    *Node,
  86.                 *Next;
  87.         BYTE         GotIt = FALSE;
  88.         LONG         Result;
  89.  
  90.         Node = List -> lh_Head;
  91.  
  92.         while(Next = Node -> ln_Succ)
  93.         {
  94.             if((Result = Stricmp(Name,Node -> ln_Name)) < 0)
  95.             {
  96.                 Insert(List,NewNode,Node -> ln_Pred);
  97.  
  98.                 GotIt = TRUE;
  99.  
  100.                 break;
  101.             }
  102.             else
  103.             {
  104.                     /* Don't add two identical names. */
  105.  
  106.                 if(!Result)
  107.                 {
  108.                     FreeVecPooled(NewNode);
  109.  
  110.                     return;
  111.                 }
  112.             }
  113.  
  114.             Node = Next;
  115.         }
  116.  
  117.         if(!GotIt)
  118.             AddTail(List,NewNode);
  119.     }
  120. }
  121.  
  122.     /* FileMultiScan(struct List *FileList,STRPTR Directory,STRPTR Pattern):
  123.      *
  124.      *    Scan an assignment, also handles multipath assignments.
  125.      */
  126.  
  127. STATIC VOID __regargs
  128. FileMultiScan(struct List *FileList,STRPTR Directory,STRPTR Pattern,LONG Type)
  129. {
  130.     struct DevProc        *DevProc    = NULL;
  131.     struct MsgPort        *FileSysTask    = GetFileSysTask();
  132.     struct FileInfoBlock    *FileInfo;
  133.     UBYTE             MatchBuffer[MAX_FILENAME_LENGTH];
  134.  
  135.     if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  136.     {
  137.             /* Allocate the fileinfo data. */
  138.  
  139.         if(FileInfo = (struct FileInfoBlock *)AllocDosObjectTags(DOS_FIB,TAG_DONE))
  140.         {
  141.                 /* Loop until all assignments are
  142.                  * processed.
  143.                  */
  144.  
  145.             do
  146.             {
  147.                     /* Get the default filesystem task
  148.                      * in case we stumble upon NULL
  149.                      * directory locks.
  150.                      */
  151.  
  152.                 if(DevProc = GetDeviceProc(Directory,DevProc))
  153.                 {
  154.                         /* Set the default filesystem task. */
  155.  
  156.                     SetFileSysTask(DevProc -> dvp_Port);
  157.  
  158.                         /* Check the object type. */
  159.  
  160.                     if(Examine(DevProc -> dvp_Lock,FileInfo))
  161.                     {
  162.                             /* Is it really a directory? */
  163.  
  164.                         if(FileInfo -> fib_DirEntryType > 0)
  165.                         {
  166.                                 /* Scan the directory... */
  167.  
  168.                             while(ExNext(DevProc -> dvp_Lock,FileInfo))
  169.                             {
  170.                                     /* Did we find a file? */
  171.  
  172.                                 if(FileInfo -> fib_DirEntryType < 0)
  173.                                 {
  174.                                         /* Does the name match the template? */
  175.  
  176.                                     if(MatchPatternNoCase(MatchBuffer,FileInfo -> fib_FileName))
  177.                                     {
  178.                                         if(Type == -1)
  179.                                             AddFile(FileList,FileInfo -> fib_FileName);
  180.                                         else
  181.                                         {
  182.                                             UBYTE LocalBuffer[MAX_FILENAME_LENGTH],RealName[MAX_FILENAME_LENGTH];
  183.  
  184.                                             strcpy(LocalBuffer,Directory);
  185.  
  186.                                             if(AddPart(LocalBuffer,FileInfo -> fib_FileName,MAX_FILENAME_LENGTH))
  187.                                             {
  188.                                                 if(ValidateFile(LocalBuffer,Type,RealName))
  189.                                                     AddFile(FileList,RealName);
  190.                                             }
  191.                                         }
  192.                                     }
  193.                                 }
  194.                             }
  195.                         }
  196.                     }
  197.                 }
  198.                 else
  199.                     break;
  200.             }
  201.             while(DevProc && (DevProc -> dvp_Flags & DVPF_ASSIGN));
  202.  
  203.                 /* Free the fileinfo data. */
  204.  
  205.             FreeDosObject(DOS_FIB,FileInfo);
  206.         }
  207.     }
  208.  
  209.         /* Reset the default filesystem task. */
  210.  
  211.     SetFileSysTask(FileSysTask);
  212.  
  213.         /* Free device process data. */
  214.  
  215.     if(DevProc)
  216.         FreeDeviceProc(DevProc);
  217. }
  218.  
  219.     /* FreeFileList(struct List *List):
  220.      *
  221.      *    Free a list and list contents.
  222.      */
  223.  
  224. STATIC VOID __regargs
  225. FreeFileList(struct List *List)
  226. {
  227.     struct Node    *Node,
  228.             *Next;
  229.  
  230.     Node = List -> lh_Head;
  231.  
  232.     while(Next = Node -> ln_Succ)
  233.     {
  234.         FreeVecPooled(Node);
  235.  
  236.         Node = Next;
  237.     }
  238.  
  239.     FreeVecPooled(List);
  240. }
  241.  
  242.     /* IsAssign(STRPTR Name):
  243.      *
  244.      *    Does a name refer to an assignment?
  245.      */
  246.  
  247. STATIC BYTE __regargs
  248. IsAssign(STRPTR Name)
  249. {
  250.     WORD NameLen    = strlen(Name) - 1;
  251.     BYTE Result    = FALSE;
  252.  
  253.         /* Does it end with a colon? */
  254.  
  255.     if(Name[NameLen] == ':')
  256.     {
  257.         struct DosList *DosList;
  258.  
  259.             /* Lock the list of assignments for reading. */
  260.  
  261.         DosList = AttemptLockDosList(LDF_ASSIGNS | LDF_READ);
  262.  
  263.             /* Make sure the v37 bug doesn't catch us. */
  264.  
  265.         if(((ULONG)DosList) > 1)
  266.         {
  267.             STRPTR AssignName;
  268.  
  269.                 /* Scan the list... */
  270.  
  271.             while(DosList = NextDosEntry(DosList,LDF_ASSIGNS))
  272.             {
  273.                     /* Convert the name from icky
  274.                      * BCPL to `C' style string.
  275.                      */
  276.  
  277.                 AssignName = (STRPTR)BADDR(DosList -> dol_Name);
  278.  
  279.                     /* Does the name length match? */
  280.  
  281.                 if(AssignName[0] == NameLen)
  282.                 {
  283.                         /* Does the name itself match? */
  284.  
  285.                     if(!Strnicmp(&AssignName[1],Name,NameLen))
  286.                     {
  287.                         Result = TRUE;
  288.  
  289.                         break;
  290.                     }
  291.                 }
  292.             }
  293.  
  294.                 /* Unlock the list of assignments. */
  295.  
  296.             UnLockDosList(LDF_ASSIGNS | LDF_READ);
  297.         }
  298.     }
  299.  
  300.         /* Return the result. */
  301.  
  302.     return(Result);
  303. }
  304.  
  305.     /* BuildFileList(STRPTR Directory,STRPTR Pattern):
  306.      *
  307.      *    Build a list of files in an assigned directory
  308.      *    matching a certain pattern.
  309.      */
  310.  
  311. STATIC struct List * __regargs
  312. BuildFileList(STRPTR Directory,STRPTR Pattern,LONG Type)
  313. {
  314.     APTR         OldPtr = ThisProcess -> pr_WindowPtr;
  315.     struct List    *FileList = NULL;
  316.     BPTR         NewDir;
  317.  
  318.         /* No DOS requesters, please! */
  319.  
  320.     ThisProcess -> pr_WindowPtr = (APTR)-1;
  321.  
  322.         /* Is the assignment present? */
  323.  
  324.     if(NewDir = Lock(Directory,ACCESS_READ))
  325.     {
  326.             /* Allocate space for the new list. */
  327.  
  328.         if(FileList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  329.         {
  330.                 /* Initialize the list. */
  331.  
  332.             NewList(FileList);
  333.  
  334.                 /* Will we have to deal with
  335.                  * an assignment or a volume?
  336.                  */
  337.  
  338.             if(IsAssign(Directory))
  339.                 FileMultiScan(FileList,Directory,Pattern,Type);
  340.             else
  341.             {
  342.                 struct FileInfoBlock    *FileInfo;
  343.                 UBYTE             MatchBuffer[MAX_FILENAME_LENGTH];
  344.  
  345.                 if(ParsePatternNoCase(Pattern,MatchBuffer,MAX_FILENAME_LENGTH) != -1)
  346.                 {
  347.                         /* Allocate space for a fileinfo block. */
  348.  
  349.                     if(FileInfo = (struct FileInfoBlock *)AllocDosObjectTags(DOS_FIB,TAG_DONE))
  350.                     {
  351.                             /* Take a look at the assignment. */
  352.  
  353.                         if(Examine(NewDir,FileInfo))
  354.                         {
  355.                                 /* Does it really refer to a directory? */
  356.  
  357.                             if(FileInfo -> fib_DirEntryType > 0)
  358.                             {
  359.                                     /* Examine the whole directory. */
  360.  
  361.                                 while(ExNext(NewDir,FileInfo))
  362.                                 {
  363.                                         /* Is it a file? */
  364.  
  365.                                     if(FileInfo -> fib_DirEntryType < 0)
  366.                                     {
  367.                                         if(MatchPatternNoCase(MatchBuffer,FileInfo -> fib_FileName))
  368.                                         {
  369.                                             if(Type == -1)
  370.                                                 AddFile(FileList,FileInfo -> fib_FileName);
  371.                                             else
  372.                                             {
  373.                                                 UBYTE LocalBuffer[MAX_FILENAME_LENGTH],RealName[MAX_FILENAME_LENGTH];
  374.  
  375.                                                 strcpy(LocalBuffer,Directory);
  376.  
  377.                                                 if(AddPart(LocalBuffer,FileInfo -> fib_FileName,MAX_FILENAME_LENGTH))
  378.                                                 {
  379.                                                     if(ValidateFile(LocalBuffer,Type,RealName))
  380.                                                         AddFile(FileList,RealName);
  381.                                                 }
  382.                                             }
  383.                                         }
  384.                                     }
  385.                                 }
  386.                             }
  387.                         }
  388.  
  389.                             /* Free the fileinfo data. */
  390.  
  391.                         FreeDosObject(DOS_FIB,FileInfo);
  392.                     }
  393.                 }
  394.             }
  395.  
  396.                 /* Does the list contain any entries? */
  397.  
  398.             if(!FileList -> lh_Head -> ln_Succ)
  399.             {
  400.                 FreeVecPooled(FileList);
  401.  
  402.                 FileList = NULL;
  403.             }
  404.         }
  405.  
  406.             /* Release the lock on the directory. */
  407.  
  408.         UnLock(NewDir);
  409.     }
  410.  
  411.         /* Enable DOS requesters again. */
  412.  
  413.     ThisProcess -> pr_WindowPtr = OldPtr;
  414.  
  415.         /* Return the file name list. */
  416.  
  417.     return(FileList);
  418. }
  419.  
  420.     /* PickFile(STRPTR Directory,STRPTR Pattern,STRPTR Prompt,STRPTR Name):
  421.      *
  422.      *    Your nice file selection routine. No need to hunt for
  423.      *    a library/device by checking all assignments by hand.
  424.      */
  425.  
  426. BYTE __regargs
  427. PickFile(struct Window *Window,STRPTR Directory,STRPTR Pattern,STRPTR Prompt,STRPTR Name,LONG Type)
  428. {
  429.     UBYTE              DummyBuffer[MAX_FILENAME_LENGTH],
  430.                 *DummyChar;
  431.     struct FileRequester    *FileRequest;
  432.     struct List        *FileList;
  433.     BYTE             Result = FALSE;
  434.  
  435.     if(FileList = BuildFileList(Directory,Pattern,Type))
  436.     {
  437.         struct LayoutHandle *Handle;
  438.     
  439.         if(Handle = LT_CreateHandleTags(Window -> WScreen,
  440.             LH_LocaleHook,    &LocaleHook,
  441.         TAG_DONE))
  442.         {
  443.             struct Window    *Window;
  444.             ULONG         Index = (ULONG)~0,i;
  445.             struct Node    *Node;
  446.  
  447.             for(Node = FileList -> lh_Head, i = 0 ; Node -> ln_Succ ; Node = Node -> ln_Succ, i++)
  448.             {
  449.                 if(!Stricmp(Node -> ln_Name,Name))
  450.                 {
  451.                     Index = i;
  452.  
  453.                     break;
  454.                 }
  455.             }
  456.  
  457.             LT_New(Handle,
  458.                 LA_Type,    VERTICAL_KIND,
  459.             TAG_DONE);
  460.             {
  461.                 LT_New(Handle,
  462.                     LA_Type,    VERTICAL_KIND,
  463.                     LA_LabelID,    MSG_V36_1269,
  464.                 TAG_DONE);
  465.                 {
  466.                     LT_New(Handle,
  467.                         LA_Type,    LISTVIEW_KIND,
  468.                         LA_LabelID,    MSG_TERMPICKFILE_FILE_LIST_GAD,
  469.                         LA_Chars,    40,
  470.                         LA_ID,        GAD_LIST,
  471.                         LA_Lines,    10,
  472.                         LALV_MaxGrowY,    20,
  473.                         GTLV_Labels,    FileList,
  474.                         GTLV_Selected,    Index,
  475.                         LALV_Link,    NIL_LINK,
  476.                         LALV_CursorKey,    TRUE,
  477.                     TAG_DONE);
  478.     
  479.                     LT_EndGroup(Handle);
  480.                 }
  481.     
  482.                 LT_New(Handle,
  483.                     LA_Type,VERTICAL_KIND,
  484.                 TAG_DONE);
  485.                 {
  486.                     LT_New(Handle,
  487.                         LA_Type,    XBAR_KIND,
  488.                         LAXB_FullSize,    TRUE,
  489.                     TAG_DONE);
  490.     
  491.                     LT_EndGroup(Handle);
  492.                 }
  493.  
  494.                 LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  495.                     LAGR_SameSize,    TRUE,
  496.                     LAGR_Spread,    TRUE,
  497.                 TAG_DONE);
  498.                 {
  499.                     LT_New(Handle,
  500.                         LA_Type,    BUTTON_KIND,
  501.                         LA_LabelID,    MSG_GLOBAL_USE_GAD,
  502.                         LA_ID,        GAD_USE,
  503.                         LABT_ReturnKey,    TRUE,
  504.                         LABT_ExtraFat,    TRUE,
  505.                     TAG_DONE);
  506.     
  507.                     LT_New(Handle,
  508.                         LA_Type,    BUTTON_KIND,
  509.                         LA_LabelID,    MSG_TERMPICKFILE_SELECT_GAD,
  510.                         LA_ID,        GAD_SELECT,
  511.                         LABT_ExtraFat,    TRUE,
  512.                     TAG_DONE);
  513.     
  514.                     LT_New(Handle,
  515.                         LA_Type,    BUTTON_KIND,
  516.                         LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  517.                         LA_ID,        GAD_CANCEL,
  518.                         LABT_EscKey,    TRUE,
  519.                         LABT_ExtraFat,    TRUE,
  520.                     TAG_DONE);
  521.     
  522.                     LT_EndGroup(Handle);
  523.                 }
  524.     
  525.                 LT_EndGroup(Handle);
  526.             }
  527.     
  528.             if(Window = LT_Layout(Handle,Prompt,NULL,0,0,IDCMP_CLOSEWINDOW,0,
  529.                 LAWN_HelpHook,        &GuideHook,
  530.                 WA_DepthGadget,        TRUE,
  531.                 WA_CloseGadget,        TRUE,
  532.                 WA_DragBar,        TRUE,
  533.                 WA_RMBTrap,        TRUE,
  534.                 WA_Activate,        TRUE,
  535.             TAG_DONE))
  536.             {
  537.                 struct IntuiMessage    *Message;
  538.                 BOOLEAN             Done = FALSE;
  539.                 ULONG             MsgClass,
  540.                              MsgQualifier;
  541.                 UWORD             MsgCode;
  542.                 struct Gadget        *MsgGadget;
  543.     
  544.                 LT_ShowWindow(Handle,TRUE);
  545.  
  546.                 PushWindow(Window);
  547.     
  548.                 do
  549.                 {
  550.                     if(Wait(PORTMASK(Window -> UserPort) | SIG_BREAK) & SIG_BREAK)
  551.                         break;
  552.     
  553.                     while(Message = (struct IntuiMessage *)GT_GetIMsg(Window -> UserPort))
  554.                     {
  555.                         MsgClass    = Message -> Class;
  556.                         MsgQualifier    = Message -> Qualifier;
  557.                         MsgCode        = Message -> Code;
  558.                         MsgGadget    = (struct Gadget *)Message -> IAddress;
  559.     
  560.                         GT_ReplyIMsg(Message);
  561.     
  562.                         LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  563.     
  564.                         if(MsgClass == IDCMP_CLOSEWINDOW)
  565.                             Done = TRUE;
  566.     
  567.                         if(MsgClass == IDCMP_GADGETUP)
  568.                         {
  569.                             switch(MsgGadget -> GadgetID)
  570.                             {
  571.                                 case GAD_USE:
  572.  
  573.                                     if(Index != (ULONG)~0)
  574.                                     {
  575.                                         struct Node *Node = GetListNode(Index,FileList);
  576.  
  577.                                         if(Node)
  578.                                         {
  579.                                             strcpy(Name,Node -> ln_Name);
  580.  
  581.                                             Result = TRUE;
  582.                                         }
  583.                                     }
  584.  
  585.                                     Done = TRUE;
  586.                                     break;
  587.     
  588.                                 case GAD_CANCEL:
  589.     
  590.                                     Done = TRUE;
  591.                                     break;
  592.  
  593.                                 case GAD_LIST:
  594.  
  595.                                     Index = MsgCode;
  596.                                     break;
  597.  
  598.                                 case GAD_SELECT:
  599.  
  600.                                     LT_LockWindow(Window);
  601.  
  602.                                     SplitFileName(Name,&DummyChar,DummyBuffer);
  603.  
  604.                                     if(FileRequest = GetFile(Window,Prompt,DummyBuffer,DummyChar,DummyBuffer,Pattern,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  605.                                     {
  606.                                         STRPTR FileName;
  607.  
  608.                                         if(FileRequest -> rf_NumArgs > 1 && FileRequest -> rf_ArgList)
  609.                                             FileName = FileRequest -> rf_ArgList -> wa_Name;
  610.                                         else
  611.                                             FileName = FileRequest -> rf_File;
  612.  
  613.                                         if(!Stricmp(FileRequest -> rf_Dir,Directory))
  614.                                             strcpy(Name,FileName);
  615.                                         else
  616.                                             strcpy(Name,DummyBuffer);
  617.  
  618.                                         if(Type != -1)
  619.                                         {
  620.                                             UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  621.  
  622.                                             if(!Stricmp(FileRequest -> rf_Dir,Directory))
  623.                                             {
  624.                                                 strcpy(LocalBuffer,Directory);
  625.  
  626.                                                 if(AddPart(LocalBuffer,Name,MAX_FILENAME_LENGTH))
  627.                                                     ValidateFile(LocalBuffer,Type,Name);
  628.                                             }
  629.                                             else
  630.                                             {
  631.                                                 if(ValidateFile(DummyBuffer,Type,LocalBuffer))
  632.                                                 {
  633.                                                     strcpy(Name,DummyBuffer);
  634.  
  635.                                                     DummyChar = PathPart(Name);
  636.  
  637.                                                     *DummyChar = 0;
  638.  
  639.                                                     AddPart(Name,LocalBuffer,MAX_FILENAME_LENGTH);
  640.                                                 }
  641.                                             }
  642.                                         }
  643.  
  644.                                         FreeAslRequest(FileRequest);
  645.  
  646.                                         Done = Result = TRUE;
  647.                                     }
  648.  
  649.                                     LT_UnlockWindow(Window);
  650.  
  651.                                     break;
  652.                             }
  653.                         }
  654.  
  655.                         if(MsgClass == IDCMP_IDCMPUPDATE)
  656.                         {
  657.                             struct Node *Node = GetListNode(Index = MsgCode,FileList);
  658.  
  659.                             if(Node)
  660.                             {
  661.                                 strcpy(Name,Node -> ln_Name);
  662.  
  663.                                 Done = Result = TRUE;
  664.  
  665.                                 LT_PressButton(Handle,GAD_USE);
  666.                             }
  667.                         }
  668.                     }
  669.                 }
  670.                 while(!Done);
  671.     
  672.                 PopWindow();
  673.             }
  674.     
  675.             LT_DeleteHandle(Handle);
  676.         }
  677.  
  678.         DeleteList(FileList);
  679.     }
  680.     else
  681.     {
  682.         SplitFileName(Name,&DummyChar,DummyBuffer);
  683.  
  684.         if(FileRequest = GetFile(Window,Prompt,DummyBuffer,DummyChar,DummyBuffer,Pattern,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  685.         {
  686.             STRPTR FileName;
  687.  
  688.             if(FileRequest -> rf_NumArgs > 1 && FileRequest -> rf_ArgList)
  689.                 FileName = FileRequest -> rf_ArgList -> wa_Name;
  690.             else
  691.                 FileName = FileRequest -> rf_File;
  692.  
  693.             if(!Stricmp(FileRequest -> rf_Dir,Directory))
  694.                 strcpy(Name,FileName);
  695.             else
  696.                 strcpy(Name,DummyBuffer);
  697.  
  698.             if(Type != -1)
  699.             {
  700.                 UBYTE LocalBuffer[MAX_FILENAME_LENGTH];
  701.  
  702.                 if(!Stricmp(FileRequest -> rf_Dir,Directory))
  703.                 {
  704.                     strcpy(LocalBuffer,Directory);
  705.  
  706.                     if(AddPart(LocalBuffer,Name,MAX_FILENAME_LENGTH))
  707.                         ValidateFile(LocalBuffer,Type,Name);
  708.                 }
  709.                 else
  710.                 {
  711.                     if(ValidateFile(DummyBuffer,Type,LocalBuffer))
  712.                     {
  713.                         strcpy(Name,DummyBuffer);
  714.  
  715.                         DummyChar = PathPart(Name);
  716.  
  717.                         *DummyChar = 0;
  718.  
  719.                         AddPart(Name,LocalBuffer,MAX_FILENAME_LENGTH);
  720.                     }
  721.                 }
  722.             }
  723.  
  724.             FreeAslRequest(FileRequest);
  725.  
  726.             return(TRUE);
  727.         }
  728.     }
  729.  
  730.     return(Result);
  731. }
  732.